NiMo syntax: part 1

Many formalisms for the specification for concurrent and distributed systems have emerged. In particular considering boxes and strings approaches. Examples are action calculi, rewriting logic and graph rewriting, bigraphs. The boxes and string metaphor is addressed with different levels of granularity. One of the approaches is to consider a process network as an hypergraph. Based in this general framework, we encode NiMo nets as a class of Annotated hypergraphs. This class is defined by giving the alphabet and the operations used to construct such programs. Therefore we treat only editing operations on labelled hypergraphs and afterwards how this editing operation affects the graph. Graph transformation (execution rules) is not covered here.Postprint (published version

Exploiting parallelism by customizing evaluation

NiMo is a totally graphic language from the family of Higher Order Typed languages with a strong Data flow inspiration. The interpreter is a specialized graph transformation system, and therefore the language operational semantics is given in terms of graph transformations. In NiMo parallelization is implicit and the evaluation policy is customizable following a process-centered approach. Here we explore some of the methodological possibilities that it opens. Some classical examples illustrate how combining modes greatly increases processor usage, decreases channel population, and achieves subnet synchronization in a very easy and intuitive way. We also present a stream programming technique and a real case application for generative and multistage-programming.Peer ReviewedPostprint (author’s final draft

NiMoToons: a totally graphic workbench for program tuning and experimentation

NiMo (Nets In Motion) is a Graphic-Functional-Data Flow language designed to visualize algorithms and their execution in an understandable way. Programs are process networks that evolve showing the full state at each execution step. Processes are polymorphic, higher order and have multiple outputs. The language has a set of primitive processes well suited for stream programming and supports open programs and interactive debugging. The new version of the environment NiMo Toons includes: an also graphic and incremental type inference system, multiple output processes as higher order parameters, symbolic execution, five evaluation modes that can be globally or locally set for each process and dynamically changed, and facilities to measure the used resources (parallelism level, number of steps, number of processes, etc.)Postprint (author’s final draft

Graphical type inference: A graph grammar definition

We present a graph grammar based type inference system for a totally graphic language inspired in the data flow view of lazy functional programs. NiMo (Nets in Motion) can be seen as a graphic equivalent to Haskell that acts as an on-line tracer and debugger. The user not only sees the results but also the way they are calculated according to an understandable model and can interrupt the execution at any point, change data, processes and/or process activation, undo steps, and also execute incomplete programs. Type inference is incremental; during the net edition (construction or modification) only type safe connections are allowed. The user visualises the type information evolution and, in case of type error, can identify where and why it happened. The NiMo type system, though similar, has significant differences with systems in functional languages due to the data flow ingredient. It needs to cope with processes with no entries and zero or more that one output and therefore the process type is a generalization of functional types. We present the notion of non-structural type unification, the elements for modelling graphic type inference, and the correspondence with the classical type inference approach. Construction and execution of NiMo programs are fully defined via an attributed graph grammar. In the previous version type information was incomplete and static type inference was partial in presence of polymorphism. Therefore type inconsistent nets could be executed. Here we present the type descriptor graphs and the graph grammar definition of the complete static type inference system. The grammar has been implemented and successfully tested using AGG as the graph transformation system.Postprint (published version

Implementing static synchronous sensor fields using NiMo

In this work we present some implementations of a Static Synchronous Sensor Field (SSSF), a static and synchronous model for sensor networks in which a finite set of sensing devices are geographically distributed and can communicate among them. We used for implementations the NiMo (Nets in Motion) programming language, a graphic-functional-data flow language that allows a step by step visualization of the executions of an algorithm, making visible all the involved elements. Experimenting with sensor networks gives an insight of their behavior and aids to see their properties.Postprint (published version

Exploiting parallelism by customizing evaluation

NiMo is a totally graphic language from the family of Higher Order Typed languages with a strong Data flow inspiration. The interpreter is a specialized graph transformation system, and therefore the language operational semantics is given in terms of graph transformations. In NiMo parallelization is implicit and the evaluation policy is customizable following a process-centered approach. Here we explore some of the methodological possibilities that it opens. Some classical examples illustrate how combining modes greatly increases processor usage, decreases channel population, and achieves subnet synchronization in a very easy and intuitive way. We also present a stream programming technique and a real case application for generative and multistage-programming.Peer Reviewe

Exploiting parallelism by customizing evaluation

NiMo is a totally graphic language from the family of Higher Order Typed languages with a strong Data flow inspiration. The interpreter is a specialized graph transformation system, and therefore the language operational semantics is given in terms of graph transformations. In NiMo parallelization is implicit and the evaluation policy is customizable following a process-centered approach. Here we explore some of the methodological possibilities that it opens. Some classical examples illustrate how combining modes greatly increases processor usage, decreases channel population, and achieves subnet synchronization in a very easy and intuitive way. We also present a stream programming technique and a real case application for generative and multistage-programming.Peer Reviewe

Graphical type inference: A graph grammar definition

We present a graph grammar based type inference system for a totally graphic language inspired in the data flow view of lazy functional programs. NiMo (Nets in Motion) can be seen as a graphic equivalent to Haskell that acts as an on-line tracer and debugger. The user not only sees the results but also the way they are calculated according to an understandable model and can interrupt the execution at any point, change data, processes and/or process activation, undo steps, and also execute incomplete programs. Type inference is incremental; during the net edition (construction or modification) only type safe connections are allowed. The user visualises the type information evolution and, in case of type error, can identify where and why it happened. The NiMo type system, though similar, has significant differences with systems in functional languages due to the data flow ingredient. It needs to cope with processes with no entries and zero or more that one output and therefore the process type is a generalization of functional types. We present the notion of non-structural type unification, the elements for modelling graphic type inference, and the correspondence with the classical type inference approach. Construction and execution of NiMo programs are fully defined via an attributed graph grammar. In the previous version type information was incomplete and static type inference was partial in presence of polymorphism. Therefore type inconsistent nets could be executed. Here we present the type descriptor graphs and the graph grammar definition of the complete static type inference system. The grammar has been implemented and successfully tested using AGG as the graph transformation system

Development of algebraic specifications with constraints

A formal framework for the development of algebraic specifications is presented. Ther main issues concerning the approach are the following: we allow to deal with incomplete specifications during the design process. This is handled by means of loose semantics and initial constraints. The design process is considered bi-dimensional. Horizontal refinements express, as usual, extensions. Vertical refinements consists in adding more detail or completing the refined specifications. The usual composition properties for refinements hold in our framework. In addition, the horizontal composition theorem defines a generalization of parameter passing as it is usually understood.Postprint (published version

Graphical and incremental type inference: a graph transformation approach

We present a graph grammar based type inference system for a totally graphic development language. NiMo (Nets in Motion) can be seen as a graphic equivalent to Haskell that acts as an on-line tracer and debugger. Programs are process networks that evolve giving total visibility of the execution state, and can be interactively completed, changed or stored at any step. In such a context, type inference must be incremental. During the net construction or modification only type safe connections are allowed. The user visualises the type information evolution and, in case of conflict, can easily identify the causes. Though based on the same ideas, the type inference system has significant differences with its analogous in functional languages. Process types are a non-trivial generalization of functional types to handle multiple outputs, partial application in any order, and curried-uncurried coercion. Here we present the elements to model graphical inference, the notion of structural and non-structural equivalence of type graphs, and a graph unification and composition calculus for typing nets in an incremental way